import javax.naming.PartialResultException;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public class j5 {
/*//    public static int max2(int a,int b){
//        return a>b?a:b;
//    }
//    public static int max3(int a,int b,int c){
//        int max=max2(a,b);
//        return max2(max,c);
//    }*/
    /*public static void main(String[] args){
          int[] array={1,2,3,4};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]+" ");
        }
        System.out.println();*/

        /*for-each遍历数组
        int[] array={1,2,3,4};
        for(int x: array){ //数组存储值:数组名  循环->每接收一次打印一次
            System.out.println(x);
        }
        System.out.println();*/

    /*public static void func1(int[] array){
        array=new int[10];//形参地址指向一个新的数组，不改变实参指向内容
    }

    public static void func2(int[] array){
        array[0]=99;//实参地址与形参地址指向同一个数组，通过形参改变实参内容
    }

    public static void main(String[] args) {

        int[] array1 = {1, 2, 3, 4};
        func1(array1);
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]+" ");
        }
        System.out.println();//1 2 3 4

        int[] array2={1,2,3,4};
        func2(array2);
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]+" ");
        }
        System.out.println();//99 2 3 4
    }*/

    /*public static int[] func3(){
        int[] array={1,2,3,4,5,6};
        return array;
        //return new int[]{1,2,3,4,5};
    }*/

   /* public static void main(String[] args) {
        int[] ret=func3();
       *//* for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]+" ");
        }*//*
        //借助工具类
        //将参数的数组转化为字符串输出
        String s=Arrays.toString(ret);//import java.util.Arrays; //Arrays是java中专门用来操作数组的
        System.out.println(s);
        //System.out.println(Arrays.toString(ret));*/

   /* //写一段程序实现tostring
    public static String myToString(int[] array) {
        String ret = "[";
        for (int i = 0; i < array.length; i++) {
            ret += array[i];
            if (i != array.length - 1) {
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }

    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        String ret=myToString(array);
        System.out.println(ret);
    }*/

    //数组拷贝
    /*public static void main(String[] args) {
        int array[]={1,2,3,4,5};
        int[] copy=new int[array.length];
        //1.通过for循环进行拷贝
        for (int i = 0; i < array.length; i++) {
            copy[i]=array[i];
        }
        System.out.println(Arrays.toString(copy));

        //下面一段代码不是拷贝
        int[] array2={1,2,3,4,5};
        int[] array3=array2;
        System.out.println(Arrays.toString(array3));
*/
        //2.通过工具类进行拷贝
   /* public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] copy=Arrays.copyOf(array,array.length);//数组拷贝
        int[] copy1=Arrays.copyOf(array,array.length*2);//数组扩容 {1,2,3,4,5,0,0,0,0,0}
        Arrays.copyOfRange(array,1,3);//拷贝下标为[1,3)-->{2,3}
        System.out.println(Arrays.toString(copy));
    }*/

    //3.通过函数拷贝
    /*public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] copy=new int[array.length*2];//这里可以扩容一下
        //System.arraycopy(源数组,源数组拷贝起始位置,目的数组,目的数组拷贝起始位置,拷贝长度);
        System.arraycopy(array,0,copy,0,array.length);//这里length不可*2,否则越界
        System.out.println(Arrays.toString(copy));*/

    //数据查找
    //for循环操作
    /*
    public static int findVal(int[] array,int x){
        for (int i = 0; i < array.length; i++) {
           if(array[i]==x){
               return i;
           }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        System.out.println(findVal(array,5));
    }*/

    //二分查找
  /*  public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        Arrays.sort(array);//数组排序方法
        System.out.println(Arrays.toString(array));
    }*/
   /* public static int binrySearch(int[] array,int key){
        int left=0;
        int right=array.length-1;
        while(left<=right){
            int mid=(left+right)/2;
            if(array[mid]<key){
                left=mid+1;
            }else if(array[mid]>key){
                right=mid-1;
            }else{
                return mid;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] array={1,2,13,4,5};
        System.out.println(binrySearch(array,13));
    }*/

    //方法实现
   /* public static void main(String[] args) {
        int[] array={1,2,13,14,28};
        Arrays.binarySearch(array,14);
    }*/

    //比较两个数组 对应位置 数据是否一样
   /* public static void main(String[] args) {
        int[] array1={1,2,3,4,5};
        int[] array2={1,2,3,44,5};
        boolean flg=Arrays.equals(array1,array2);
        System.out.println(flg);
    }*/

    //帮你直接填充数据
    /*public static void main(String[] args) {
        int[] array=new int[10];
        Arrays.fill(array,-1);
        Arrays.fill(array,1,4,-1);//从位置[1,4)
        System.out.println(Arrays.toString(array));
    }
*/

    //冒泡排序
    /*public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            boolean flg=false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]){
                    int tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                    flg=true;
                }
            }
            if(flg==false){
                break;//说明有序了
            }
        }
    }
    public static void main(String[] args) {
        int[] array={1,2,3,4,5};

    }*/

    //作业
    //1.实现方法 transform, 以数组为参数,循环将数组中的每个元素乘以 2 ,
    //<1>并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
    public static void transform(int[] array){
        for (int i = 0; i < array.length; i++) {
            array[i]*=2;
        }
    }
    //<2>创建一个新数组来存放扩大后的数组
    public static int[] transform2(int[] array){
        int[] ret=new int[array.length];
        for (int i = 0; i < array.length; i++) {
            ret[i]=array[i]*2;
        }
        return ret;//main函数要有数组接收返回值
    }
    //2.实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
    public static int avg(int[] array){
        int sum=0;
        for (int i = 0; i < array.length; i++) {
            sum+=array[i];
        }
        return sum/array.length;//若除数和被除数都是整型，要返回一个小数，则左右两边至少一个为double类型
    }
    //***3.调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序
    public static void func3(int[] array){
        int i=0;
        int j=array.length-1;
        while(i<j){
            while(i<j&&array[i]%2!=0){
                i++;
            }
            while(i<j&&array[j]%2==0){
                j--;
            }
            int tmp=array[i];
            array[i]=array[j];
            array[j]=tmp;
        }
    }
    //4.给定一个整型数组, 实现冒泡排序(升序排序)
    public static void bubble(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j]>array[j+1]){
                    int tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                }
            }
        }
    }
    //5.给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标

    public static int[] twoSum(int[] nums,int target){
        int[] result=new int[2];
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = nums.length; j >i; j--) {
                if(nums[i]+nums[j]==target){
                    result[0]=i;
                    result[1]=j;
                }
            }
        }
        return result;
    }

    public static int[] twoSum2(int[] array,int target){
        for (int i = 0; i <array.length-1 ; i++) {
            for (int j = 1; j <array.length ; j++) {
                if(array[i]+array[j]==target){
                    return new int[]{i,j};
                }
            }
        }
        return new int[]{-1,-1};
    }


    //5.给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

    public static int solution(int[] array){
        int n=0;
        for (int i = 0; i <array.length ; i++) {
            n^=array[i];
        }
        return n;
    }

   /* public static void main(String[] args) {
        //int[] array={1,2,3,4,5};
        //int[] num={2,7,4,1};
        int[] array={1,2,1,4,4};
        int a=solution(array);
        System.out.println(a);
        //transform(array);
        //func3(array);
        //int[] result=twoSum(num,9);
        //bubble(array);
        //int a= avg(array);
        //System.out.println(Arrays.toString(result));
        //System.out.println(a);
*/

    //6.给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
    //你可以假设数组是非空的，并且给定的数组总是存在多数元素。
    //因为多数元素出现的次数是大于⌊ n/2 ⌋的，所以在进行排序后的数，中位数一定是多数元素
   /* public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入元素个数");
        int n=scan.nextInt();
        int[] arr=new int[n];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=scan.nextInt();
        }
        if (arr.length == 1) {
            System.out.println(arr[0]);
        }
        Arrays.sort(arr);
        System.out.println(arr[arr.length / 2]);
    }
*/

    //7.给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false
    public static boolean threeConsecutiveOdds(int[] array){
        boolean flg=false;
        for (int i = 0; i < array.length-3; i++) {
            if(array[i]%2!=0&&array[i+1]%2!=0&&array[i+2]!=0){
                flg=true;
                return flg;
            }
        }
        return false;
    }

    public static boolean threeConsecutiveOdds2(int[] array){
        int count=0;
        for (int i = 0; i < array.length; i++) {
            if(array[i]%2!=0){
                count++;
                if(count==3){
                    return true;
                }
            } else{
                count=0;
            }
        }
        return false;
    }


    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        boolean a=threeConsecutiveOdds(array);
        System.out.println(a);
    }
    }




















































